from time import time, sleep


from pyDemin import *
from client import *
from wxPython.lib.dialogs import *


#classe d'affichage du demineur
class DeminWindowReseau(wx.Panel):
    def __init__(self, parent, ID,partie,nomJ):
        wx.Panel.__init__(self,parent,ID)
        self.SetSize(parent.GetClientSize())
        self.wm=30
        self.hm=30

        #recuperation des donnees relatives a la partie
        self.nomPartie=partie[0]
        self.nbJoueurs=partie[1]
        self.difficulte=partie[2]
        self.nomJoueurs=partie[3]
        self.nomJ=nomJ

        self.compteurs=[0]*self.nbJoueurs#declaration des compteurs

        #declaration de variables de traitement
        self.x=0
        self.y=0
        self.typ=None
        self.nomEnCours=""
        self.test=True
        self.fin=None
        
        #determine si joueur doit demarrer la partie ou pas
        self.premier=False
        self.atoi=False
        self.atoiAV=False
        if self.nomJ==self.nomJoueurs[0]:
            self.premier=True
            self.atoi=True

        #determination du nombre de bombe dans la partie en fonction de la difficulte
        if self.difficulte=="Facile":
            self.nb=45
        elif self.difficulte=="Moyen":
            self.nb=85
        elif self.difficulte=="Difficile":
            self.nb=120
        else:
            self.difficulte=int(self.difficulte)
            self.nb=self.difficulte*45-(self.difficulte-1)*5#determination du nb de mines dans le jeu

        self.game=pyDemin(30,30,self.nb)#initialisation du jeu en lui-meme

        self.parent=parent

        self.init_buffer()#initialisation du buffer


        self.Bind(wx.EVT_PAINT,self.OnPaint)
        self.Bind(wx.EVT_LEFT_DOWN,self.OnLeft)
        self.Bind(wx.EVT_RIGHT_DOWN,self.OnRight)
        self.Bind(wx.EVT_CLOSE,self.Close)

        self.parent.rejoint=False


    def Close(self,evt):#le joueur choisi de quitter la partie
        msg=wx.MessageDialog(self,"\n Etes-vous sur de vouloir quitter la partie ?","Attention",wx.YES_NO)
        rep=msg.ShowModal()
        msg.Destroy()
        if rep==5103:#s'il clique sur ok
            msg=wx.MessageDialog(self,"\n Vous allez etre redirige vers l'accueil","Attention",wx.OK)
            rep=msg.ShowModal()
            msg.Destroy()
            self.parent.client.mySocketEmission.send("quitte\n"+self.parent.client.mySocketEmission.send(self.nomJ))
            self.parent.Destroy()
        
                
    def OnLeft(self,evt):#quand le joueur clique gauche
        if self.fin!=None:
            self.affiche()
            return
        if self.atoi:#si c'est le tour du joueur
            x,y = evt.GetPosition()
            if x>0 and x<600 and y>0 and y<600:#si le clic est bien dans la fenetre du demineur
                a=x/20
                b=y/20
                if self.premier:#si le joueur doit demarrer la partie
                    self.game.debut(a,b)#1er clic, qui ne doit pas etre sur une bombe
                    matrice=self.transfoMatrice()#transformation de la matrice en chaine de caracteres
                    self.parent.client.mySocketEmission.send("matrice\n"+matrice)#envoi de la matrice au serveur
                    self.premier=False#le joueur n'est plus premier
                else:#sinon
                    self.game.decouvre(a,b)#decouvrement la grille
                self.atoi=False#ce n'est plus son tour
                self.atoiAV=True#il vient de jouer
                mm=self.refresh(a,b,"left")#rafraichissement de la fenetre
                self.parent.SetStatusText("Il reste %d mines"%(self.nb-mm))
                #sleep(2)
        else:#si ce n'est pas le tour du joueur
            msg=wx.MessageDialog(self,"\n Ce n'est pas votre tour","Attention",wx.OK|wx.ICON_ERROR)
            rep=msg.ShowModal()
            msg.Destroy()
        self.Compteurs()

    def transfoMatrice(self):#fonction de transformation de la matrice
        matrice=self.game.mine#recuperation de la matrice
        s=""
        if len(matrice)!=self.wm*self.hm:#si la taille est differente de celle attendue
            print "soucis"
            sys.exit(-1)
        for i in range(len(matrice)-1):#pour l'ensemble de la matrice
            s+=str(matrice[i])+","#transformation des entiers en caractere
        s+=str(matrice[i])
        return s

    def OnRight(self,evt):#quand le joueur clique droit pour marquer une mine
        if self.fin!=None:
            self.affiche()
            return
        if self.atoi:#si c'est le tour du joueur
            x,y = evt.GetPosition()
            if x>0 and x<600 and y>0 and y<600:#si le clic est bien dans la fenetre du demineur
                a=x/20
                b=y/20
                index=self.nomJoueurs.index(self.nomJ)#recuperation de l'index du joueur
                if self.game.mine[b*self.game.w+a]==-1:#si c'est sur une mine
                    self.compteurs[index]+=2#incrementation du compteur
                    self.game.aamine(a,b)#decouvrement de la case
                    self.atoi=False#ce n'est plus son tour
                    self.atoiAV=True
                    mm=self.refresh(a,b,"right")#rafraichissement de la fenetre
                    pas=False
                    self.parent.SetStatusText("Il reste %d mines"%(self.nb-mm))
                else:#si c'est pas un mine
                    msg=wx.MessageDialog(self,"\n Il n'y a pas de bombe ici\n Vous perdez un point","Rate",wx.OK)#information du joueur qu'il est pas bon
                    rep=msg.ShowModal()
                    msg.Destroy()
                    self.compteurs[index]-=1#desincrementation du compteur
                    pas=True
                    self.atoi=False#ce n'est plus son tour
                    self.atoiAV=False
                self.Compteurs()#mise a jour des compteurs
                self.parent.client.mySocketEmission.send("modificationCompteur\n"+self.nomJ+"\n"+str(self.compteurs[index]))
                print "envoie compteur"
#envoi de la modification de compteur
                if pas:#s'il n'y avait pas de mines
                    self.parent.client.mySocketEmission.send("pass")
        else:#si ce n'est pas son tour
            msg=wx.MessageDialog(self,"\n Ce n'est pas votre tour","Attention",wx.OK|wx.ICON_ERROR)
            rep=msg.ShowModal()
            msg.Destroy()
        self.Compteurs()
                
    def OnPaint(self,evt):
        dc = wx.BufferedPaintDC(self,self.buffer)
    
    def init_buffer(self):#initialisation du buffer
        w,h = self.GetClientSize()
        self.buffer = wx.EmptyBitmap(600,600)#definition d'une image pour dessiner le demineur
        dc = wx.BufferedDC(wx.ClientDC(self),self.buffer)
        self.draw(dc)
        cb=wx.StaticText(self,19,"Partie : "+ self.nomPartie,(680,50),size=(270,40))#affichage du nom de la partie
        self.init=True
        self.Compteurs()#affichage des compteurs
        self.init=False

    def Compteurs(self):#affichage des compteurs des joueurs
        for i in range(self.nbJoueurs):#parcours des compteurs des joueurs
            if self.init:
                cb=wx.StaticText(self,19,self.nomJoueurs[i],(640,135+i*60),size=(100,50))#affichage du nom du joueur
            txtP=wx.TextCtrl(self,30,str(self.compteurs[i]),(800,130+i*60),size=(50,30))#affichage du compteur
        
	
    def draw(self,dc):#dessin du fond quadrille de la fenetre
        dc.Clear()
        dc.SetBrush(wx.Brush("grey"))
        dc.SetPen(wx.Pen("black",1))
        for i in range(30):
            for j in range(30):
                dc.DrawRectangle(i*20,j*20,20,20)

    def decouvrir(self,x,y,typ):#decouvrement quand c'est un autre joueur
        if self.typ=="left":#si c'est 1 clic gauche
            self.game.decouvre(x,y)#decouvrement de la grille
        else:#sinon
            self.game.aamineAJ(x,y)#enregistrement d'une bombe decouverte par 1 autre joueur
        mm=self.refresh(x,y,typ)#rafraichissement
        self.typ=None

    def refresh(self,a,b,typ):#rafraichissement de la fenetre
        dc = wx.BufferedDC(wx.ClientDC(self),self.buffer)
        dc.Clear()
        dc.SetPen(wx.Pen("black",1))
        t=True
        nb=0
        mm=0
        for i in range(30):
            for j in range(30):
                if self.game.dec[j*self.game.w+i]==0:#si la case n'est pas decouverte
                    dc.SetBrush(wx.Brush("grey"))
                    dc.DrawRectangle(i*20,j*20,20,20)
                elif self.game.dec[j*self.game.w+i]==-1:#si la case est marquee, par le joueur
                    if self.game.mine[j*self.game.w+i]==-1:#s'il y a bien une mine a cet endroit
                        dc.SetBrush(wx.Brush("red"))
                        dc.DrawRectangle(i*20,j*20,20,20)
                        mm+=1
                    else:
                        msg=wx.MessageDialog(self,"\n PB","Perdu",wx.OK)
                        rep=msg.ShowModal()
                        print "PB"
                            
                elif self.game.dec[j*self.game.w+i]==-2:#si la case est marquee par un autre joueur
                    dc.SetBrush(wx.Brush("blue"))
                    dc.DrawRectangle(i*20,j*20,20,20)
                    mm+=1
                elif self.game.mine[j*self.game.w+i]==-1:#s'il y a une mine sur la case
                    t=False
                        #affichage d'un message pour dire qu'il a perdu
                    if self.nbJoueurs==2:
                        index=self.nomJoueurs.index(self.nomJ)
                        self.parent.client.mySocketEmission.send("finPartie\n"+self.nomJoueurs[1-index])
                    else:
                        self.parent.client.mySocketEmission.send("aPerdu\n"+self.nomJ)
                    msg=wx.MessageDialog(self,"\n Vous avez clique sur une bombe\n Vous avez perdu \n\n Vous allez etre redirige vers l'accueil","Perdu",wx.OK)
                    rep=msg.ShowModal()
                    msg.Destroy()
                    self.parent.Destroy()
                else:#sinon
                    dc.SetBrush(wx.Brush("white"))
                    dc.DrawRectangle(i*20,j*20,20,20)
                    k=self.game.grille[j*self.game.w+i]
                    if k!=0 :
                        dc.DrawText("%d"%k,i*20+5,j*20+2)
                    nb+=1

        if mm==self.nb:#si le nombre de bombes a decouvrir est atteint
            t=False
            index=self.nomJoueurs.index(self.nomJ)
            if self.compteurs[index]==max(self.compteurs):#si le joueur a le score maximal
                #le joueur a gagne
                msg=wx.MessageDialog(self,"\n Felicitation \n Vous avez gagne \n \nVous allez etre redirige vers l'accueil","Gagne",wx.OK)
                rep=msg.ShowModal()
                #envoi de l'information au serveur
                self.parent.client.mySocketEmission.send("finPartie\n"+self.nomJ)
                self.parent.Destroy()
                msg.Destroy()
            else:#sinon
                #un autre joueur a gagne
                ind=self.compteurs.index(max(self.compteurs))
                msg=wx.MessageDialog(self,"\n Vous avez trouve la derniere bombe \n Mais vous n'avez pas le score maximal \n  \n\n Vous allez etre redirige vers l'accueil","Fin Partie",wx.OK)
                rep=msg.ShowModal()
                #envoi de l'information au serveur
                self.parent.client.mySocketEmission.send("finPartie\n"+self.Joueurs[ind])
                self.parent.Destroy()
                msg.Destroy()

        if t and self.atoiAV:#si rien n'a deja ete envoye et si le joueur est le bon
            self.parent.client.mySocketEmission.send("clic\n"+str(a)+","+str(b)+","+typ)
            self.atoiAV=False
        return mm

    def matrice(self,matrice):#enregistrement de la matrice des mines
        self.game.mine=matrice

    def affiche(self):
        if self.fin=="perdantContinu":
            self.affichePerdantContinue(self.nomJoueur)
        elif self.fin=="quitte":
            self.afficheQuitte(self.nomJoueur)
        elif self.fin=="perdu":
            self.affichePerdu()
        elif self.fin=="gagne":
            self.afficheGagne()
        else:
            print "pb fin"
        self.fin=None

    def affichePerdantContinue(self,joueurPerdant):#joueurPerdant a perdu mais la partie continu
        msg=wx.MessageDialog(self,"\n Le joueur " +joueurPerdant+" a perdu \n La partie continue","Un joueur perdant",wx.OK)
        rep=msg.ShowModal()
        self.nomJoueurs.remove(joueurPerdant)#suppression du joueurPerdant de la liste des joueurs et des compteurs
        self.nbJoueurs-=1
        self.compteurs()
        msg.Destroy()

    def afficheQuitte(self,joueurQuittant):
        msg=wx.MessageDialog(self,"\n Le joueur " +joueurQuittant+" a quitte la partie \n La partie continue","Un joueur part...",wx.OK)
        rep=msg.ShowModal()
        self.nomJoueurs.remove(joueurQuittant)#suppression du joueurPerdant de la liste des joueurs et des compteurs
        self.nbJoueurs-=1
        self.compteurs()
        msg.Destroy()

    def affichePerdu(self):#affichage des gagnants
        msg=wx.MessageDialog(self,"\n Vous avez perdu \n \nVous allez etre redirige vers l'accueil","Perdu",wx.OK)
        rep=msg.ShowModal()
        msg.Destroy()
        self.parent.Destroy()

    def afficheGagne(self):#affichage que le joueur a gagne
        msg=wx.MessageDialog(self,"\n Vous avez gagne !!! Felicitation !!! \n \nVous allez etre redirige vers l'accueil","Gagne",wx.OK)
        rep=msg.ShowModal()
        msg.Destroy()
        self.parent.Destroy()

    def modifCompteur(self,nomJoueur,newVal):#modification du compteur de nomJoueur
        index=self.nomJoueurs.index(nomJoueur)
        self.compteurs[index]=newVal
        print "modif compteur"
        #self.Compteurs()




#Classe Affichage Parties En Cours
class Aff(wx.Panel):
    def __init__(self, parent, ID,nb,parties,typ,deb,fin,suiv,prec):
        wx.Panel.__init__(self,parent,ID)
        self.ID=ID
        self.parent=parent
        self.SetSize(parent.GetClientSize())
        self.nb=nb 
        self.parties=parties
        self.deb=deb
        self.fin=fin
        self.suiv=suiv
        self.prec=prec
        self.init_buffer(typ)#initialisation du buffer
        

    def init_buffer(self,typ):#initialisation du buffer
        w,h = self.GetClientSize()
        self.buffer = wx.EmptyBitmap(w,h)
        
        if typ=="partiesEnCours":#s'il faut afficher la liste des parties disponibles

            PartyEnCours=wx.Button(self,0,"Nouvelle Partie",(20,20),size=(170,40))
            self.parent.Bind(wx.EVT_BUTTON,self.parent.newParty,id=0)

            Refresh = wx.Button(self,1,"Rafraichir",(420,20),size=(100,40))
            self.parent.Bind(wx.EVT_BUTTON,self.parent.refresh, id=1)

            Close =wx.Button(self,2,"Fermer",(775,20),size=(100,40))
            self.parent.Bind(wx.EVT_BUTTON,self.parent.close, id=2)

            if self.nb==0:#s'il n'y a pas de partie disponible
                self.affNonParties()#affichage du message d'information
            else:#sinon
                self.affichagePartieParties()#affichage des parties disponibles

        elif typ=="newParty":#s'il faut afficher le formulaire de remplissage pour une nouvelle partie
            PartyEnCours=wx.Button(self,0,"Parties en cours",(20,20),size=(170,40))
            self.parent.Bind(wx.EVT_BUTTON,self.parent.refresh,id=0)

            Close =wx.Button(self,2,"Fermer",(775,20),size=(100,40))
            self.parent.Bind(wx.EVT_BUTTON,self.parent.close, id=2)

            self.newParty()#affichage du formulaire de remplissage

        elif typ=="choix":#s'il faut afficher la demande de confirmation du choix de la partie
            PartyEnCours=wx.Button(self,0,"Parties en cours",(20,20),size=(170,40))
            self.parent.Bind(wx.EVT_BUTTON,self.parent.refresh,id=0)

            Close =wx.Button(self,2,"Fermer",(775,20),size=(100,40))
            self.parent.Bind(wx.EVT_BUTTON,self.parent.close, id=2)

            self.choix()#demande de confirmation

    def affNonParties(self):#affichage du fait qu'il n'y a aucune partie disponible             
        cb=wx.StaticText(self,19,"Il n'y a actuellement aucune partie en attente sur le reseau",(100,200),size=(600,60))

    def affichagePartieParties(self):#affichage d'une partie des parties disponibles
        pos=90
        t=70
        ide=200
        for i in range(self.deb,self.fin):
            bt="Nombre de joueurs attendus : "+str(self.parties[i][2])+"\n"
            bt+="Nombre de joueurs deja presents : "+str(self.parties[i][4])+"\n"
            bt+="Difficulte : "+str(self.parties[i][3])
            b=wx.Button(self,ide,bt,(20,pos),(860,t))
            pos+=t
            self.parent.Bind(wx.EVT_BUTTON,self.parent.choixPartie,id=ide)
            ide+=1
            
        if self.prec:#s'il faut afficher le bouton precedent
            precedent=wx.Button(self,110,"Parties Precedents",(20,600),(150,40))
            self.parent.Bind(wx.EVT_BUTTON,self.parent.prec,id=110)
        if self.suiv:#s'il faut afficher le bouton suivant
            suivant=wx.Button(self,100,"Parties Suivantes",(730,600),(150,40))
            self.parent.Bind(wx.EVT_BUTTON,self.parent.suivant,id=100)
    

    def newParty(self):#affichage du formulaire de nouvelle partie

        cb=wx.StaticText(self,19,"Entrez les donnees pour une nouvelle partie",(325,150),size=(600,60))
        
        cb=wx.StaticText(self,20,"Pseudo",(150,225),size=(260,30))
        cb=wx.StaticText(self,21,"Nom de la partie",(150,265),size=(260,30))
        cb=wx.StaticText(self,22,"Nombre de joueurs attendus (entre 2 et 8)",(150,305),size=(260,30))
        cb=wx.StaticText(self,23,"Difficulte",(150,345),size=(260,30))

        txtP=wx.TextCtrl(self,30,"",(500,220),size=(250,30),style=wx.TE_PROCESS_ENTER)
        self.parent.Bind(wx.EVT_TEXT,self.parent.textPseudo,txtP)
        txtNP=wx.TextCtrl(self,31,"",(500,260),size=(250,30),style=wx.TE_PROCESS_ENTER)
        self.parent.Bind(wx.EVT_TEXT,self.parent.textNomPartie,txtNP)
        txtNb=wx.TextCtrl(self,32,"",(500,300),size=(250,30),style=wx.TE_PROCESS_ENTER)
        self.parent.Bind(wx.EVT_TEXT,self.parent.textNb,txtNb)
        radDiff=wx.RadioBox(self,33,choices=["Facile","Moyen","Difficile"],style=wx.RA_SPECIFY_ROWS,majorDimension=0,pos=(500,340),size=(250,100))
        self.parent.Bind(wx.EVT_RADIOBOX,self.parent.diff,radDiff)
        self.parent.difficulte="Facile"

        Val=wx.Button(self,50,"Valider",(440,500),(100,40))
        self.parent.Bind(wx.EVT_BUTTON,self.parent.valNew,id=50)

    def choix(self):#afichage de la confirmation et demande de pseudo
        cb=wx.StaticText(self,19,"Vous avez choisi la partie :",(180,150),size=(600,60))
    
        cb=wx.StaticText(self,21,"Nom de la partie",(150,220),size=(260,30))
        cb=wx.StaticText(self,22,"Nombre de joueurs attendus",(150,260),size=(260,30))
        cb=wx.StaticText(self,23,"Difficulte",(150,300),size=(260,30))
        cb=wx.StaticText(self,-1,"Votre pseudo",(150,350),size=(260,30))

        cb=wx.StaticText(self,30,self.parties[0],(500,220),size=(250,30))
        cb=wx.StaticText(self,31,str(self.parties[1]),(500,260),size=(250,30))
        cb=wx.StaticText(self,32,str(self.parties[2]),(500,300),size=(250,30))
        txtP=wx.TextCtrl(self,31,"",(500,350),size=(250,30),style=wx.TE_PROCESS_ENTER)
        self.parent.Bind(wx.EVT_TEXT,self.parent.textPseudo,txtP)


        Val=wx.Button(self,50,"Valider",(440,500),(100,40))
        self.parent.Bind(wx.EVT_BUTTON,self.parent.valChoice,id=50)

        

#Classe pour lier le client et rejoindre le serveur	
class GameReseauFrame(wx.Frame):
    def __init__(self, parent, ID, title, pos=wx.DefaultPosition,size=wx.DefaultSize, style=wx.DEFAULT_FRAME_STYLE):
	
        wx.Frame.__init__(self, parent, ID, title, pos, size, style)
        self.SetAutoLayout(True)
        self.Panel=None
        self.msg=None
        self.partie=None
        self.client=None
        
        self.Bind(wx.EVT_CLOSE,self.Close)

    def initialisationClient(self,port,host):#initialisation de la liaison client-serveur
        debutClient(port,host,self)
        sleep(0.25)
        self.Panel=Aff(self,-1,self.nb,self.parties,"partiesEnCours",self.deb,self.fin,self.suiv,self.prec)
        
        



    def Close(self,evt):#le joueur choisi de quitter la partie
        msg=wx.MessageDialog(self,"\n Etes-vous sur de vouloir quitter la partie ?","Attention",wx.YES_NO)
        rep=msg.ShowModal()
        msg.Destroy()
        if rep==5103:#s'il clique sur ok
            msg=wx.MessageDialog(self,"\n Vous allez etre redirige vers l'accueil","Attention",wx.OK)
            rep=msg.ShowModal()
            msg.Destroy()
            if self.partie!=None:
                self.client.mySocketEmission.send("quitte\n"+self.nomJoueur)
            self.Destroy()
        
    def affichagePartieDisp(self,nb,parties):#affichage des parties disponibles sur le reseau
        self.nb=nb
        self.parties=parties

        if nb==0:#s'il n'y a aucune partie disponible sur le reseau
            self.deb=0
            self.fin=0
            self.suiv=False
            self.prec=False
                         
        elif nb>7:#si le nombre de parties disponibles est sup. a 7 (taille limite d'affichage)
            self.deb=0
            self.fin=7
            self.suiv=True
            self.prec=False
 
        else:#sinon
            self.deb=0
            self.fin=nb
            self.suiv=False
            self.prec=False

    def suivant(self,evt):#quand le joueur a clique sur le bouton suivant (cas ou le nombre de parties disponibles est superieur a 7)
        self.deb=self.fin
        if self.fin+7>self.nb:#si le nombre de parties restantes a afficher est inferieur a 7
            self.fin=self.nb
            suiv=False#pas besoin d'un bouton suivant
        else:#sinon
            self.fin+=7
            suiv=True#besoin d'un bouton suivant
        self.panel=Aff(self,-1,self.nb,self.parties,"partiesEnCours",self.deb,self.fin,suiv,True)#affichage des parties suivantes avec 1 bouton precedent et/ou pas un bouton suivant

    def prec(self,evt):#quand le joueur a clique sur le bouton precedent (cas ou le nombre de parties disponibles est superieur a 7)
        self.fin=self.deb
        self.deb-=7
        if self.deb==0:#si on arrive aux premieres parties
            prec=False #pas besoin d'un bouton precedent
        else:#sinon
            prec=True#besoin d'un bouton precedent
        self.panel=Aff(self,-1,self.nb,self.parties,"partiesEnCours",self.deb,self.fin,True,prec)#affichage des parties precedentes avec 1 bouton suivant et/ou pas un bouton precedent


    def refresh(self,evt): #quand le joueur clique sur le bouton "Rafraichir"
        self.client.mySocketEmission.send("listePartiesEnAttente")#demande au serveur de la nouvelle liste de parties disponibles


    def close(self,evt):#quand le joueur choisi de quitter la partie
        self.client.Termine=True
        self.Destroy()


    def choixPartie(self,evt):#quand le joueur a choisi une partie qui l'interesse
        self.num=evt.GetId()#recuperation du numero d'identifiant du bouton
        self.num=self.num-(200-self.deb)#transformation du numero pour obtenir le vrai numero de la partie
        
        #enregistrement de donnees de la partie
        self.nomJoueur=""
        self.nomPartie=self.parties[self.num][1]
        self.nbJoueursAttendus=self.parties[self.num][2]
        self.difficulte=self.parties[self.num][3]
        self.Joueurs=self.parties[self.num][5::]
        partie=[self.nomPartie,self.nbJoueursAttendus,self.difficulte,self.Joueurs]#rassemblement des donnees

        self.panel=Aff(self,-1,1,partie,"choix",0,0,0,0)#demande au joueur si c'est bien la partie qu'il a choisi et d'entrer son pseudo pour la partie                    


    def newParty(self,evt):#quand le joueur choisi d'initialiser une nouvelle partie
        self.nomJoueur=""
        self.nomPartie=""
        self.difficulte=""
        self.nbJoueursAttendus=""

        self.panel=Aff(self,-1,0,[],"newParty",0,0,0,0)#affichage d'une fenetre ou le joueur entre les caracteristiques de la partie


    def textPseudo(self,evt):#enregistrement du pseudo du joueur
        self.nomJoueur=evt.GetString()
        if self.partie!=None:#si c'est dans le cas ou slt le pseudo du joueur etait demande (confirmation de choix de partie)
            self.Joueurs.append(self.nomJoueur)
        else:
            self.Joueurs=[self.nomJoueur]
        

    def textNomPartie(self,evt):#enregistrement du nom de la partie
        self.nomPartie=evt.GetString()

    def textNb(self,evt):#enregistrement du nom de joueurs attendus
        if re.search(r"^[0-9]+$",evt.GetString())!=None:#si le nb entree est bien un entier
            self.nbJoueursAttendus=int(evt.GetString())
        else:#sinon
            msg=wx.MessageDialog(self,"\n Le caractere entree n'est pas un entier","Erreur",wx.OK|wx.ICON_ERROR)
            rep=msg.ShowModal()
            msg.Destroy()
            

    def diff(self,evt):#enregistrement de la difficulte de la partie
        self.difficulte=evt.GetSelection()
        if self.difficulte==1:
            self.difficulte="Moyen"
        elif self.difficulte==2:
            self.difficulte="Difficile"
        else:
            self.difficulte="Facile"
        print "difficulte"
        print self.difficulte

    def valNew(self,evt):#quand le joueur qui initialise une partie, clique sur valider 
        if self.nomJoueur!="" and self.nomPartie!="" and self.nbJoueursAttendus!="" and self.difficulte!="":#si toutes les donnees entrees sont correctes
            #envoi de l'information du serveur
            self.client.mySocketEmission.send("partie\n"+self.nomPartie+","+str(self.nbJoueursAttendus)+","+str(self.difficulte)+","+str(1)+","+self.nomJoueur)
            #le joueur doit attendre que le nb de joueurs attendus soit atteint        
            self.msg=wx.MessageDialog(self,"\n Vous devez attendre que d'autres joueurs rejoignent la partie","Attente",style=wx.ICON_INFORMATION)
            rep=self.msg.ShowModal()
            self.rejoindrePartie()  

        else:#sinon
            #Affichage d'une fenetre d'erreur
            msg=wx.MessageDialog(self,"\n Au moins un des champs n est pas ou mal renseigne","Erreur",wx.ICON_ERROR)
            rep=msg.ShowModal()
            msg.Destroy()

    def valChoice(self,evt):
        if self.nomJoueur!="":
            self.client.mySocketEmission.send("numPartieChoisie\n"+str(self.parties[self.num][0])+"\n"+"nomJoueur\n"+self.nomJoueur)

            if self.nbJoueursAttendus==self.parties[self.num][4]+1:#si le nombre de joueurs attendus est atteint
                self.msg=wx.MessageDialog(self,"\n La partie va demarrer","Attente",style=wx.ICON_INFORMATION)
                self.rejoindrePartie()#rejoint la partie
            else:#sinon
                self.msg=wx.MessageDialog(self,"\n Tous les joueurs attendus ne sont pas la \n Veuillez attendre que tous les joueurs soient la","Attente",style=wx.ICON_INFORMATION)#il faut faire attendre le joueur
                rep=self.msg.ShowModal()
                self.rejoindrePartie()#rejoint la partie
        else:#il y a un probleme
            print "pas nom"
        
    
    def debutPartie(self,listeJoueurs):#la partie peut commencer, tous les joueurs attendus ont rejoint la partie
        if self.msg!=None:#si une fenetre d'attente etait ouverte
            self.msg.Destroy()#destruction
        self.Joueurs=listeJoueurs#enregistrement de la liste finale des joueurs
        self.rejoint=True
        self.partie=[self.nomPartie,self.nbJoueursAttendus,self.difficulte,self.Joueurs]#enregistrement de la partie

    def Matrice(self,matrice):#enregistrement de la matrice dans le jeu
        self.jeu.matrice(matrice)

    def Tour(self):#c'est au joueur de jouer
        while self.rejoint==True:#tant que le jeu n'a pas ete correctement initialise
            i=0 #attente
        self.jeu.atoi=True#

    def modifCompteur(self,nomJoueur,newVal):#modification du compteur de nomJoueur avec newVal
        print "modifCompteur"
        self.jeu.modifCompteur(nomJoueur,newVal)

    def decouvrement(self,clic,typ,nom):#decouvrement de la grille en fonction du type de clic
        #enregistrement temporaire des donnees
        self.jeu.x=clic[0]
        self.jeu.y=clic[1]
        self.jeu.nomEnCour=nom
        self.jeu.typ=typ
        self.jeu.decouvrir(clic[0],clic[1],typ)#lancement de la decouverte du jeu

    def aPerdu(self,joueurPerdant):#joueurPerdant a perdu mais le jeu peut continuer
        self.jeu.fin="perdantContinu"
        self.jeu.nomJoueur=joueurPerdant
        #self.jeu.affichePerdantContinue(joueurPerdant)

    def finPartie(self,joueursGagnants):#la partie est finie, joueursGagnants ayant gagne
        if self.nomJoueur in joueursGagnants:
            self.jeu.fin="gagne"
        else:
            self.jeu.fin="perdu"

    def quitte(self,nomJ):#nomJ a quitte la partie
        self.jeu.fin="quitte"
        self.jeu.nomJoueur=nomJ
        #self.jeu.quitte(nomJ)

    def rejoindrePartie(self):#la partie commence
        while self.partie==None:#tant que la partie n'est pas vmt declaree
            i=0
                    
        menubar=wx.MenuBar()
            
        menu =wx.Menu(style=wx.MENU_TEAROFF)
        menubar.Append(menu,"&File")
        
        menu1=wx.Menu(style=wx.MENU_TEAROFF)
        menu1.Append(3,"Facile")
        menu1.Append(4,"Moyen")
        menu1.Append(5,"Difficile")
        
        menu.AppendMenu(wx.ID_OPEN,"New",menu1)
        menu.AppendSeparator()
        menu.Append(wx.ID_EXIT,"&Quit","Quit")
        
        self.SetMenuBar(menubar)
            
        self.statusBar = self.CreateStatusBar() #creation de la barre d'etats
        self.CreateStatusBar()
        self.SetStatusText("Cliquez sur la grille pour jouer")
            
        self.jeu=DeminWindowReseau(self,-1,self.partie,self.nomJoueur)#lancement de la partie


